home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2010 May / Mac Life Ubuntu.iso / casper / filesystem.squashfs / usr / src / linux-headers-2.6.28-15 / arch / cris / include / asm / bitops.h < prev    next >
Encoding:
C/C++ Source or Header  |  2008-12-24  |  4.3 KB  |  167 lines
  1. /* asm/bitops.h for Linux/CRIS
  2.  *
  3.  * TODO: asm versions if speed is needed
  4.  *
  5.  * All bit operations return 0 if the bit was cleared before the
  6.  * operation and != 0 if it was not.
  7.  *
  8.  * bit 0 is the LSB of addr; bit 32 is the LSB of (addr+1).
  9.  */
  10.  
  11. #ifndef _CRIS_BITOPS_H
  12. #define _CRIS_BITOPS_H
  13.  
  14. /* Currently this is unsuitable for consumption outside the kernel.  */
  15. #ifdef __KERNEL__ 
  16.  
  17. #ifndef _LINUX_BITOPS_H
  18. #error only <linux/bitops.h> can be included directly
  19. #endif
  20.  
  21. #include <arch/bitops.h>
  22. #include <asm/system.h>
  23. #include <asm/atomic.h>
  24. #include <linux/compiler.h>
  25.  
  26. /*
  27.  * set_bit - Atomically set a bit in memory
  28.  * @nr: the bit to set
  29.  * @addr: the address to start counting from
  30.  *
  31.  * This function is atomic and may not be reordered.  See __set_bit()
  32.  * if you do not require the atomic guarantees.
  33.  * Note that @nr may be almost arbitrarily large; this function is not
  34.  * restricted to acting on a single-word quantity.
  35.  */
  36.  
  37. #define set_bit(nr, addr)    (void)test_and_set_bit(nr, addr)
  38.  
  39. /*
  40.  * clear_bit - Clears a bit in memory
  41.  * @nr: Bit to clear
  42.  * @addr: Address to start counting from
  43.  *
  44.  * clear_bit() is atomic and may not be reordered.  However, it does
  45.  * not contain a memory barrier, so if it is used for locking purposes,
  46.  * you should call smp_mb__before_clear_bit() and/or smp_mb__after_clear_bit()
  47.  * in order to ensure changes are visible on other processors.
  48.  */
  49.  
  50. #define clear_bit(nr, addr)  (void)test_and_clear_bit(nr, addr)
  51.  
  52. /*
  53.  * change_bit - Toggle a bit in memory
  54.  * @nr: Bit to change
  55.  * @addr: Address to start counting from
  56.  *
  57.  * change_bit() is atomic and may not be reordered.
  58.  * Note that @nr may be almost arbitrarily large; this function is not
  59.  * restricted to acting on a single-word quantity.
  60.  */
  61.  
  62. #define change_bit(nr, addr) (void)test_and_change_bit(nr, addr)
  63.  
  64. /**
  65.  * test_and_set_bit - Set a bit and return its old value
  66.  * @nr: Bit to set
  67.  * @addr: Address to count from
  68.  *
  69.  * This operation is atomic and cannot be reordered.  
  70.  * It also implies a memory barrier.
  71.  */
  72.  
  73. static inline int test_and_set_bit(int nr, volatile unsigned long *addr)
  74. {
  75.     unsigned int mask, retval;
  76.     unsigned long flags;
  77.     unsigned int *adr = (unsigned int *)addr;
  78.     
  79.     adr += nr >> 5;
  80.     mask = 1 << (nr & 0x1f);
  81.     cris_atomic_save(addr, flags);
  82.     retval = (mask & *adr) != 0;
  83.     *adr |= mask;
  84.     cris_atomic_restore(addr, flags);
  85.     return retval;
  86. }
  87.  
  88. /*
  89.  * clear_bit() doesn't provide any barrier for the compiler.
  90.  */
  91. #define smp_mb__before_clear_bit()      barrier()
  92. #define smp_mb__after_clear_bit()       barrier()
  93.  
  94. /**
  95.  * test_and_clear_bit - Clear a bit and return its old value
  96.  * @nr: Bit to clear
  97.  * @addr: Address to count from
  98.  *
  99.  * This operation is atomic and cannot be reordered.  
  100.  * It also implies a memory barrier.
  101.  */
  102.  
  103. static inline int test_and_clear_bit(int nr, volatile unsigned long *addr)
  104. {
  105.     unsigned int mask, retval;
  106.     unsigned long flags;
  107.     unsigned int *adr = (unsigned int *)addr;
  108.     
  109.     adr += nr >> 5;
  110.     mask = 1 << (nr & 0x1f);
  111.     cris_atomic_save(addr, flags);
  112.     retval = (mask & *adr) != 0;
  113.     *adr &= ~mask;
  114.     cris_atomic_restore(addr, flags);
  115.     return retval;
  116. }
  117.  
  118. /**
  119.  * test_and_change_bit - Change a bit and return its old value
  120.  * @nr: Bit to change
  121.  * @addr: Address to count from
  122.  *
  123.  * This operation is atomic and cannot be reordered.  
  124.  * It also implies a memory barrier.
  125.  */
  126.  
  127. static inline int test_and_change_bit(int nr, volatile unsigned long *addr)
  128. {
  129.     unsigned int mask, retval;
  130.     unsigned long flags;
  131.     unsigned int *adr = (unsigned int *)addr;
  132.     adr += nr >> 5;
  133.     mask = 1 << (nr & 0x1f);
  134.     cris_atomic_save(addr, flags);
  135.     retval = (mask & *adr) != 0;
  136.     *adr ^= mask;
  137.     cris_atomic_restore(addr, flags);
  138.     return retval;
  139. }
  140.  
  141. #include <asm-generic/bitops/non-atomic.h>
  142.  
  143. /*
  144.  * Since we define it "external", it collides with the built-in
  145.  * definition, which doesn't have the same semantics.  We don't want to
  146.  * use -fno-builtin, so just hide the name ffs.
  147.  */
  148. #define ffs kernel_ffs
  149.  
  150. #include <asm-generic/bitops/fls.h>
  151. #include <asm-generic/bitops/fls64.h>
  152. #include <asm-generic/bitops/hweight.h>
  153. #include <asm-generic/bitops/find.h>
  154. #include <asm-generic/bitops/lock.h>
  155.  
  156. #include <asm-generic/bitops/ext2-non-atomic.h>
  157.  
  158. #define ext2_set_bit_atomic(l,n,a)   test_and_set_bit(n,a)
  159. #define ext2_clear_bit_atomic(l,n,a) test_and_clear_bit(n,a)
  160.  
  161. #include <asm-generic/bitops/minix.h>
  162. #include <asm-generic/bitops/sched.h>
  163.  
  164. #endif /* __KERNEL__ */
  165.  
  166. #endif /* _CRIS_BITOPS_H */
  167.